/**
 * 简化的HTTP请求工具
 */

const BASE_URL = process.env.NODE_ENV === 'development' 
  ? 'http://localhost:3000' 
  : 'https://api.liyanguangao.com'

class Request {
  constructor() {
    this.baseURL = BASE_URL
    this.timeout = 30000 // 增加超时时间到30秒
  }

  // 请求拦截器
  requestInterceptor(config) {
    // 添加认证token
    const token = uni.getStorageSync('token')
    if (token) {
      config.header = {
        ...config.header,
        'Authorization': `Bearer ${token}`
      }
    }

    // 添加通用请求头
    config.header = {
      'Content-Type': 'application/json',
      ...config.header
    }

    return config
  }

  // 响应拦截器
  responseInterceptor(response) {
    const { data, statusCode } = response

    // HTTP状态码检查 - 401未授权直接跳转登录
    if (statusCode === 401) {
      this.handleUnauthorized()
      throw new Error('未授权，请先登录')
    }

    // 接受成功的HTTP状态码：200 (OK), 201 (Created), 204 (No Content)
    if (![200, 201, 204].includes(statusCode)) {
      throw new Error(`HTTP ${statusCode}: ${data?.message || '请求失败'}`)
    }

    // 业务状态码检查
    if (data && !data.success) {
      // 检查各种未授权的情况
      if (this.isUnauthorizedError(data)) {
        this.handleUnauthorized()
        throw new Error('未授权，请先登录')
      }

      throw new Error(data.message || '请求失败')
    }

    return data
  }

  // 判断是否为未授权错误
  isUnauthorizedError(data) {
    // 检查各种可能的未授权响应格式
    return (
      data.code === 1002 || // token过期
      data.code === 401 || // 未授权状态码
      (data.message && data.message.includes('未授权')) ||
      (data.message && data.message.includes('请先登录')) ||
      (data.message && data.message.includes('登录已过期')) ||
      (data.message && data.message.includes('token')) ||
      (data.error && data.error.includes('未授权'))
    )
  }

  // 处理未授权情况
  handleUnauthorized() {
    // 清除本地存储的认证信息
    uni.removeStorageSync('token')
    uni.removeStorageSync('userInfo')
    
    // 清除store中的用户信息（如果存在）
    try {
      const app = getApp()
      if (app && app.$store) {
        app.$store.dispatch('auth/logout')
      }
    } catch (error) {
      console.warn('清除store用户信息失败:', error)
    }
    
    // 直接跳转到登录页面，不显示toast
    uni.reLaunch({
      url: '/pages/auth/login'
    })
  }

  // 基础请求方法
  request(options) {
    return new Promise((resolve, reject) => {
      // 处理URL
      let url = options.url
      if (!url.startsWith('http')) {
        url = this.baseURL + url
      }

      // 请求配置
      const config = this.requestInterceptor({
        url,
        method: options.method || 'GET',
        data: options.data,
        header: options.header || {},
        timeout: options.timeout || this.timeout
      })

      console.log('=== API请求 ===')
      console.log('URL:', config.url)
      console.log('Method:', config.method)
      console.log('Data:', config.data)
      console.log('Header:', config.header)

      uni.request({
        ...config,
        success: (response) => {
          console.log('=== API响应 ===')
          console.log('Status:', response.statusCode)
          console.log('Data:', response.data)

          try {
            const result = this.responseInterceptor(response)
            resolve(result)
          } catch (error) {
            console.error('响应处理失败:', error)
            reject(error)
          }
        },
        fail: (error) => {
          console.error('=== API请求失败 ===')
          console.error('URL:', config.url)
          console.error('Error:', error)

          // 网络错误处理
          if (error.errMsg && error.errMsg.includes('timeout')) {
            reject(new Error('请求超时，请检查网络连接'))
          } else if (error.errMsg && error.errMsg.includes('fail')) {
            reject(new Error('网络连接失败，请检查网络设置'))
          } else {
            reject(new Error(error.errMsg || '请求失败'))
          }
        }
      })
    })
  }

  // GET请求
  get(url, params = {}) {
    // 处理查询参数
    if (Object.keys(params).length > 0) {
      const queryString = Object.keys(params)
        .filter(key => params[key] !== undefined && params[key] !== null)
        .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
        .join('&')

      if (queryString) {
        url += (url.includes('?') ? '&' : '?') + queryString
      }
    }

    return this.request({
      url,
      method: 'GET'
    })
  }

  // POST请求
  post(url, data = {}) {
    return this.request({
      url,
      method: 'POST',
      data
    })
  }

  // PUT请求
  put(url, data = {}) {
    return this.request({
      url,
      method: 'PUT',
      data
    })
  }

  // DELETE请求
  delete(url, data = {}) {
    return this.request({
      url,
      method: 'DELETE',
      data
    })
  }

  // 文件上传
  upload(url, filePath, formData = {}) {
    return new Promise((resolve, reject) => {
      const token = uni.getStorageSync('token')

      uni.uploadFile({
        url: this.baseURL + url,
        filePath,
        name: 'file',
        formData,
        header: {
          'Authorization': token ? `Bearer ${token}` : ''
        },
        success: (response) => {
          try {
            const data = JSON.parse(response.data)
            if (data.success) {
              resolve(data)
            } else {
              reject(new Error(data.message || '上传失败'))
            }
          } catch (error) {
            reject(new Error('响应数据解析失败'))
          }
        },
        fail: (error) => {
          console.error('上传失败:', error)
          reject(new Error(error.errMsg || '上传失败'))
        }
      })
    })
  }
}

// 创建实例
const request = new Request()

export default request